// server/geistes.js
const Geistes = {
    // 5个Token的固定标识（比如编号1-5，也可以是文字描述）
    TOKENS: [1, 2, 3, 4, 5],
    RESOURCE_IMAGES: [
        '/images/geistes/token1.png',
        '/images/geistes/token2.png',
        '/images/geistes/token3.png',
        '/images/geistes/token4.png',
        '/images/geistes/token5.png'
    ],
    CARD_RESULT: [
      2,3,2,5,2,1,4,5,4,5,
      3,4,5,2,4,1,4,5,2,3,
      1,3,2,3,4,1,1,5,3,4,
      2,3,5,3,1,2,5,5,2,1,
      4,3,4,1,5,5,1,2,3,4,
      1,2,3,2,3,4,4,1,5,1
    ],
    CARD_TYPE: [],
    LAST_CARD: -1, // 上一张卡牌的ID
    NEXT_CARD_TIME: 1000, // 下一张卡牌的等待时间
    MAX_SCORE: 5, // 游戏获胜分数
    startGame: (room, io) => {
      console.log(`[Geistes] 房间 ${room.id} 游戏开始！`);

      // 只在第一次启动时初始化卡牌
      if (Geistes.CARD_TYPE.length === 0) {
        for (let i = 1; i <= 60; i++) {
          const num = i < 10 ? `0${i}` : i;
          const cardImage = `/images/geistes/${num}.png`;
          Geistes.CARD_TYPE.push({ url: cardImage, id: i });
          Geistes.RESOURCE_IMAGES.push(cardImage);
        }
      }

      room.gameState = Geistes.initGameState(room);

      console.log("room.gameState:", room.gameState);

      io.to(room.id).emit('game_started', {
        game: 'geistes',
        state: room.gameState,
        resource: Geistes.RESOURCE_IMAGES,
        players: room.players,
      });
      
    },

    rejoinGame: (room, io, returnedSocketId) => {
      console.log(`[Geistes] 玩家 ${returnedSocketId} 重新加入房间 ${room.id}！`);
      room.gameState = Geistes.initGameState(room);
      io.to(room.id).emit('game_started', {
        game: 'geistes',
        state: room.gameState
      });
      
    },

    handleAction: (room, socket, io, actionData) => {
      const { action, data } = actionData;
      console.log("data : ", data);
      console.log("action : ", action);
      console.log("actionData : ", actionData);

      switch (action) {
        case 'grab_token':
          Geistes.judgeTokenGrab(room, socket, io, data);
          break;
      }
    },

    // 初始化游戏状态（首次开始时调用）
    initGameState: (room) => {
      // 生成首张随机卡牌
      const firstCard = Geistes.generateRandomCard();
      // 初始化分数（所有玩家初始0分）
      const initialScores = room.players.reduce((obj, player) => {
        obj[player.id] = 0;
        return obj;
      }, {});
      // 记录玩家当前回合的选择： token, result
      const playerStatus = room.players.reduce((obj, player) => {
        obj[player.id] = { token : 0, result : false }
        return obj;
      }, {});

      return {
        gameType: 'geistes', // 游戏类型标识（和前端匹配）
        currentCard: firstCard, // 当前显示的卡牌
        scores: initialScores, // 玩家分数
        playerStatus: playerStatus, // 玩家状态，是否已经选择，是否选择正确
        isRoundActive: true, // 当前回合是否可抢（防止重复抢）
        roundCount: 1, // 回合数（可选，用于结束条件）
        maxScore: Geistes.MAX_SCORE, // 游戏获胜分数
        isGameEnded: false // 游戏是否已结束
      };
    },
  
    // 核心：生成随机卡牌（自定义规则，确保每张牌指向唯一Token）
    // 这里示例3种规则，你可以根据实际桌游规则扩展
    generateRandomCard: () => {
      // 随机选一张牌
      var card = Geistes.CARD_TYPE[Math.floor(Math.random() * Geistes.CARD_TYPE.length)];
      if (card == Geistes.LAST_CARD) {
        return Geistes.generateRandomCard();
      }
      Geistes.LAST_CARD = card;
      return card;
    },

    // 判定抢Token结果：谁先抢到正确的Token，加分并进入下一回合
    judgeTokenGrab: (room, socket, io, data) => {
      const gameState = room.gameState;
      
      // 检查游戏是否已结束
      if (gameState.isGameEnded) {
        console.log(`[Geistes] 游戏已结束，忽略Token抢取请求`);
        return null;
      }
      
      // 防止同一回合重复抢
      if (!gameState.isRoundActive) return null;
      
      // 检查该Token是否已被其他玩家选择
      const tokenAlreadySelected = Object.values(gameState.playerStatus).some(status => status.token === data.tokenId);
      if (tokenAlreadySelected) {
        console.log(`[Geistes] Token ${data.tokenId} 已被选择，忽略玩家 ${socket.id} 的请求`);
        return null;
      }
      
      // 检查该玩家是否已经选择过Token
      if (gameState.playerStatus[socket.id].token !== 0) {
        console.log(`[Geistes] 玩家 ${socket.id} 已经选择过Token，忽略重复请求`);
        return null;
      }
  
      const currentCard = gameState.currentCard;
      const result = Geistes.checkResult(currentCard, data.tokenId);

      // 更新玩家状态
      gameState.playerStatus[socket.id].token = data.tokenId;
      gameState.playerStatus[socket.id].result = result;

      if (result === true) {
        // 1. 给抢中者加分
        gameState.scores[socket.id] += 1;
        // 2. 标记回合结束，防止重复抢
        gameState.isRoundActive = false;
        
        // 3. 立即广播当前状态（包含playerStatus）
        io.to(room.id).emit('game_state_updated', {
          ...gameState,
          lastWinner: socket.id
        });

        // 4. 检查是否游戏结束
        if (gameState.scores[socket.id] >= Geistes.MAX_SCORE) {
          // 游戏结束，不再发牌
          gameState.isGameEnded = true;
          console.log(`[Geistes] 游戏结束！玩家 ${socket.id} 达到 ${Geistes.MAX_SCORE} 分获胜`);
          
          // 通知房间状态更新，隐藏"重返游戏"按钮
          io.to(room.id).emit('update_players', {
            players: room.players,
            isGameStarted: false // 游戏已结束，不再显示为进行中
          });
          
          return;
        }

        // 5. 3秒后开启下一轮（仅当游戏未结束时）
        setTimeout(() => {
          // 再次检查游戏是否已结束
          if (gameState.isGameEnded) {
            console.log(`[Geistes] 游戏已结束，停止发牌`);
            return;
          }
          
          const newCard = Geistes.generateRandomCard();
          gameState.currentCard = newCard;
          gameState.isRoundActive = true;
          gameState.roundCount += 1;
          // 重置所有玩家状态
          Object.keys(gameState.playerStatus).forEach(playerId => {
            gameState.playerStatus[playerId] = { token: 0, result: false };
          });
          // 同步给所有玩家新回合状态
          io.to(room.id).emit('game_state_updated', {
            ...gameState,
            lastWinner: null // 新回合没有上一轮赢家
          });
        }, Geistes.NEXT_CARD_TIME);
      } else {
        // 答错减分（最低0分）
        if (gameState.scores[socket.id] > 0) {
          gameState.scores[socket.id] -= 1;
        }
        
        // 检查是否所有玩家都已选择Token
        const allPlayersSelected = Object.values(gameState.playerStatus).every(status => status.token !== 0);
        
        if (allPlayersSelected) {
          console.log(`[Geistes] 所有玩家都已选择Token，切换到下一张牌`);
          // 标记回合结束
          gameState.isRoundActive = false;
          
          // 立即广播当前状态
          io.to(room.id).emit('game_state_updated', {
            ...gameState,
            lastWinner: null // 没有赢家
          });
          
          // 3秒后开启下一轮
          setTimeout(() => {
            // 检查游戏是否已结束
            if (gameState.isGameEnded) {
              console.log(`[Geistes] 游戏已结束，停止发牌`);
              return;
            }
            
            const newCard = Geistes.generateRandomCard();
            gameState.currentCard = newCard;
            gameState.isRoundActive = true;
            gameState.roundCount += 1;
            // 重置所有玩家状态
            Object.keys(gameState.playerStatus).forEach(playerId => {
              gameState.playerStatus[playerId] = { token: 0, result: false };
            });
            // 同步给所有玩家新回合状态
            io.to(room.id).emit('game_state_updated', {
              ...gameState,
              lastWinner: null // 新回合没有上一轮赢家
            });
          }, Geistes.NEXT_CARD_TIME);
          
          return; // 提前返回，避免重复发送状态更新
        }
      }
      
      // 立即更新分数状态（包含playerStatus）
      io.to(room.id).emit('game_state_updated', {
        ...gameState,
        lastWinner: result ? socket.id : null
      });
    },


    checkResult: (card, tokenID) => {
      // 简单的判定逻辑示例：
      // 根据卡牌ID的个位数来决定正确答案
      // 你可以根据实际游戏规则修改这个逻辑
      const cardId = card.id;
      return tokenID === Geistes.CARD_RESULT[cardId-1];
    },
  };
  
  module.exports = Geistes;